﻿# define _CRT_SECURE_NO_WARNINGS 1
//第17讲字符函数和字符串函数
//1. 字符分类函数
//C语⾔中有⼀系列的函数是专⻔做字符分类的，也就是⼀个字符是属于什么类型的字符的。
//这些函数的使⽤都需要包含⼀个头⽂件是 ctype.h
//以下是提取的文字内容：
//
//| 函数         | 如果他的参数符合下列条件就返回真|
//|iscntrl      | 任何控制字符|
//|isspace      | 空白字符：空格‘ ’，换页‘\f’，换行‘\n'，回车‘\r’，制表符‘\t’或者垂直制表符‘\v'|
//|isdigit      | 十进制数字‘0’~‘9’字符|
//|isxdigit     | 十六进制数字，包括所有十进制数字字符，小写字母a~f，大写字母A~F|
//|islower      | 小写字母a~z|
//|isupper      | 大写字母A~Z|
//|isalpha      | 字母a~z或A~Z|
//|isalnum      | 字母或者数字，a~z, A~Z, 0~9|
//|ispunct      | 标点符号，任何不属于数字或者字母的图形字符（可打印）|
//|isgraph      | 任何图形字符|
//|isprint      | 任何可打印字符，包括图形字符和空白字符 |
//int islower(int c);
//练习：
//写⼀个代码，将字符串中的⼩写字⺟转⼤写，其他字符不变。
#include <ctype.h>
#include <stdio.h>
//int main()
//{
//	char str[] = "Hello World.\0";
//	int i = 0;
//	char c;
//	while (str[i])
//	{
//		c = str[i];
//		if (islower(c))
//			c -= 32;
//		putchar(c);
//			i++;
//	}
//	return 0;
//}
//2. 字符转换函数
//C语⾔提供了2个字符转换函数：
//int tolower(int c); //将参数传进去的⼤写字⺟转⼩写  
//int toupper(int c); //将参数传进去的⼩写字⺟转⼤写 
//#include <ctype.h>
//#include <stdio.h>
//int main()
//{
//	char str[] = "Hello World.\0";
//	int i = 0;
//	char c;
//	while (str[i])
//	{
//		c = str[i];
//		if (islower(c))
//		 c = toupper(c);
//		putchar(c);
//			i++;
//	}
//	return 0;
//}
//3. strlen
//1 size_t strlen(const char* str);
//功能：统计参数 str 指向的字符串的⻓度。统计的是字符串中 '\0' 之前的字符的个数。参数：
//• str ：指针，指向了要统计⻓度的字符串。
//返回值：返回了 str 指向的字符串的⻓度，返回的⻓度不会是负数，所以返回类型是 size_t。
#include <stdio.h>
#include <string.h>
//int main()
//{
//	const char * str = "hello world";
//	printf("%zu", strlen(str));
//}
//使⽤注意事项：
//• 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前⾯出现的字符个数（不包
//含 '\0' )。
//• 参数指向的字符串必须要以 '\0' 结束。
//• 注意函数的返回值为 size_t ，是⽆符号的（ 易错 ）
//• strlen的使⽤需要包含头⽂件 <string.h> 
//3.2 strlen返回值
//int main()
//{
//	const char* str1 = "abcdef";
//	const char* str2 = "bbb";
//	if (strlen(str2) - strlen(str1) > 0)
//	{
//		printf("str2 > str1 \n");
//	}
//	else 
//		printf("str2 < str1 \n");
//	return 0;
//}
//输出结果：str2 > str1
//3.3 strlen的模拟实现
#include <assert.h>
//⽅式1：
//int my_strlen(const char* str)
//{
//	int count = 0;
//	assert(str);
//	while (*str)
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//int main()
//{
//	const char* str = "abcdef";
//	printf("%zu\n", strlen(str));
//	int c = my_strlen(str);
//	printf("%d\n", c);
//}
//⽅式2：
//不能创建临时变量计数器 ，函数递归
//int my_strlen(const char* str)
//{
//	assert(str);
//	if (*str == '\0')
//		return 0;
//	else
//		return 1 + my_strlen(str +1);
//}
//int main()
//{
//	const char* str = "abcdef";
//	printf("%zu\n", strlen(str));
//	int c = my_strlen(str);
//	printf("%d\n", c);
//}
//⽅式3：
//指针-指针的⽅式 指针-指针：得到的的是两个地址之间的元素个数
//int my_strlen(char* str)
//{
//	assert(str);
//	char* p = str;
//	while (*p != '\0')
//		p++;
//	return p - str;
//
//}
//int main()
//{
//	const char* str = "abcdef";
//	printf("%zu\n", strlen(str));
//	int c = my_strlen(str);
//	printf("%d\n", c);
//
//}
//4. strcpy
//代码块
//char* strcpy(char* destination, const char* source);
//功能：字符串拷⻉，拷⻉到源头字符串中的 \0 为⽌
//参数：
//destination ：指针，指向⽬的地空间
//source ：指针，指向源头数据
//返回值：
//strcpy 函数返回的⽬标空间的起始地址
//4.1 代码演⽰
//int main()
//{
//  char str1[10] = {0};
//	char str2[] = "hello";
//	
//	strcpy(str1, str2);
//	printf("%s\n", str1);
//	return 0;
//}
//使⽤注意事项：
//• 源字符串必须以 '\0' 结束。
//• 会将源字符串中的 '\0' 拷⻉到⽬标空间。
//• ⽬标空间必须⾜够⼤，以确保能存放源字符串。
//• ⽬标空间必须可修改。
//4.2 模拟实现
//char* my_strcpy(char* dest, const char* sour)
//{
//	char* ret = dest;
//	assert(dest != NULL);
//	assert(sour != NULL);
//	while ((*dest++ = *sour++))
//	{
//		;
//	}
//	return ret;
//
//}
//int main()
//{
//	char str1[10] = { 0 };
//	char str2[] = "hello";
//	my_strcpy(str1, str2);
//	printf("%s\n", str1);
//	return 0;
//}
//5. strcat
//代码块
//char* strcat(char* destination, const char* source);
//功能：字符串追加，把 source 指向的源字符串中的所有字符都追加到 destination 指向的空间
//中。
//参数：
//destination ：指针，指向⽬的地空间
//source ：指针，指向源头数据
//返回值：
//strcat 函数返回的⽬标空间的起始地址
//int main()
//{
//	char str1[20] = "hello ";
//	char str2[] = "world";
//	strcat(str1, str2);
//	printf("%s\n", str1);
//}
//使⽤注意事项：
//• 源字符串必须以 '\0' 结束。
//• ⽬标字符串中也得有 \0 ，否则没办法知道追加从哪⾥开始。
//• ⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
//• ⽬标空间必须可修改。
//5.2 模拟实现
//char* my_strcat(char* dest, const char* src)
//{
//	char* ret = dest;
//	assert(dest != NULL);
//	assert(src != NULL);
//
//	while (*dest)
//	{
//		dest++;
//	}
//	while ((*dest++ = *src++))
//	{
//		;
//	}
//	return ret;
//}
//int main()
//{
//	char str1[20] = "hello ";
//	char str2[] = "world";
//	my_strcat(str1, str2);
//	printf("%s\n", str1);
//}
//6. strcmp
//代码块
//int strcmp(const char* str1, const char* str2);
//功能：⽤来⽐较 str1 和 str2 指向的字符串，从两个字符串的第⼀个字符开始⽐较，如果两个字符
//的ASCII码值相等，就⽐较下⼀个字符。直到遇到不相等的两个字符，或者字符串结束。
//参数：
//str1 ：指针，指向要⽐较的第⼀个字符串
//str2 ：指针，指向要⽐较的第⼆个字符串
//返回值：
//• 标准规定：
//第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
//第⼀个字符串等于第⼆个字符串，则返回0
//第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字
//int strcmp(const char* str1, const char* str2);
//int main()
//{
//	/*char str1[] = "abcd";
//	char str2[] = "abcd";
//	int a = strcmp(str1, str2);
//	printf("%d", a); 第⼀个字符串等于第⼆个字符串，则返回0*/
//	/*char str1[] = "abcdf";
//	char str2[] = "abcd";
//	int a = strcmp(str1, str2);
//	printf("%d", a); 第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字*/ :1
//	char str1[] = "abcd";
//	char str2[] = "abcdf";
//	int a = strcmp(str1, str2);
//	printf("%d", a); 第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字 :-1
//	return 0;
//}
//6.2 模拟实现：
//int my_strcmp(const char* str1, const char* str2)
//{
//	int ret = 0;
//	assert(str1 != NULL);
//	assert(str2 != NULL);
//	while (*str1 == *str2)
//	{
//		if (*str1 == '\0')
//			return 0;
//		str1++;
//		str2++;
//	}
//	return *str1 - *str2;
//}
//int main()
//{
//	char str1[] = "abc";
//	char str2[] = "abcd";
//	int a = my_strcmp(str1, str2);
//	printf("%d", a); 
//	return 0;
//}
/*7*//*. strncpy
代码块
char* strncpy(char* destination, const char* source, size_t num);
功能：字符串拷⻉；将 source 指向的字符串拷⻉到 destination 指向的空间中，最多拷⻉ num
个字符。
参数：
destination ：指针，指向⽬的地空间
source ：指针，指向源头数据
num ：从source指向的字符串中最多拷⻉的字符个数
返回值：
strncpy 函数返回的⽬标空间的起始地址*/
//int main()
//{
//	char str1[20] = { 0 };
//	char str2[] = "abcdefghijk";
//	char* str3 = strncpy(str1, str2, 7);
//	printf("%s\n", str1);
//	printf("%s\n", str3);
//	return 0;
//}
//7.2 ⽐较strcpy和strncpy函数
//strcpy 函数拷⻉到 \0 为⽌，如果⽬标空间不够的话，容易出现越界⾏为。
//strncpy 函数指定了拷⻉的⻓度，源字符串不⼀定要有 \0 ，同时在设计参数的时候，就会多⼀层
//思考：⽬标空间的⼤⼩是否够⽤， strncpy 相对 strcpy 函数更加安全。
//8. strncat
//代码块
//char* strncat(char* destination, const char* source, size_t num);
//功能：字符串追加；将 source 指向的字符串的内容，追加到 destination 指向的空间，最多追
//加 num 个字符。
//参数：
//destination ：指针，指向了⽬标空间
//source ：指针，指向了源头数据
//num ：最多追加的字符的个数
//返回值：返回的是⽬标空间的起始地址
//int main()
//{
//	char str1[20] = "hello ";
//	char str2[] = "world";
//	printf("%s\n", str1);
//	char* str3 = strncat(str1, str2, 3);
//	printf("%s\n", str1);
//	printf("%s\n", str3);
//	return 0;
//}
//输出结果：
//hello
//hello wor
//hello wor
//8.2 strcat和strncat对⽐
//• 参数不同， strncat 多了⼀个参数
//• strcat 函数在追加的时候要将源字符串的所有内容，包含 \0 都追加过去，但是 strncat 函
//数指定了追加的⻓度。
//• strncat 函数中源字符串中不⼀定要有 \0 了。
//• strncat 更加灵活，也更加安全。
//9. strncmp
//代码
//int strncmp(const char* str1, const char* str2, size_t num);
//功能：字符串⽐较；⽐较 str1 和 str2 指向的两个字符串的内容，最多⽐较 num 字符。
//参数：
//str1 ：指针，指向⼀个⽐较的字符串
//str2 ：指针，指向另外⼀个⽐较的字符串
//num ：最多⽐较的字符个数
//返回值：
//• 标准规定：
//◦ 第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
//◦ 第⼀个字符串等于第⼆个字符串，则返回0
//◦ 第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字
//int main()
//{
//	/*char str1[] = "abcd";
//	char str2[] = "abcd";
//	int a = strcmp(str1, str2);
//	printf("%d", a); 第⼀个字符串等于第⼆个字符串，则返回0*/
//	/*char str1[] = "abcdf";
//	char str2[] = "abcd";
//	int a = strcmp(str1, str2);
//	printf("%d", a); 第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字*/ /*:1*/
//	char str1[] = "abcd";
//	char str2[] = "ab";
//	int a = strncmp(str1, str2,4);
//	printf("%d", a); /*第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字 :-1*/
//	return 0;
//}
//9.2 strcmp和strncmp⽐较
//• 参数不同
//• strncmp可以⽐较任意⻓度了
//• strncmp函数更加灵活，更加安全
//10. strstr
//代码块
//char* strstr(const char* str1, const char* str2);
//功能：
//strstr 函数，查找 str2 指向的字符串在 str1 指向的字符串中第⼀次出现的位置。
//简⽽⾔之：在⼀个字符串中查找⼦字符串。rw
//strstr 的使⽤得包含<string.h>
//参数：
//str1 ：指针，指向了被查找的字符串
//str2 ：指针，指向了要查找的字符串
//返回值：
//• 如果str1指向的字符串中存在str2指向的字符串，那么返回第⼀次出现位置的指针
//• 如果str1指向的字符串中不存在str2指向的字符串，那么返回NULL
//int main()
//{
//	char str1[] = "abcdefg";
//	char str2[] = "Ifai";
//	char * p = strstr(str1, str2);
//	if (p != NULL)
//		printf("%s\n", p);
//	else
//		printf("需要查找的字符串不存在\n");
//	return 0;
////}
//1/*0.2 strstr的模拟实现*/
//char* strstr(const char* str1, const char* str2)
//{
//	char* cp = (char*)str1;
//	char* s1, * s2;
//	//特殊情况：str2是空字符串时，直接返回str1 
//	if (!*str2)
//		return((char*)str1);
//	while (*cp)
//	{
//		s1 = cp;
//		s2 = (char*)str2;
//		while (*s1 && *s2 && !(*s1 - *s2))
//			s1++, s2++;
//		if (!*s2)
//			return(cp); //返回第⼀次出现的起始 
//		cp++;
//	}
//	return(NULL); //找不到则返回NULL 
//}
//11. strtok函数的使⽤
//代码块
//char* strtok(char* str, const char* delim);
//功能
//• 分割字符串：根据delim 参数中指定的分隔符，将输⼊字符串str 拆分成多个⼦字符串。
//• 修改原始字符串： strtok 会直接在原始字符串中插⼊'\0' 终⽌符，替换分隔符的位置，因
//此原始字符串会被修改。
//参数
//1. str ：⾸次调⽤时传⼊待分割的字符串；后续调⽤传⼊NULL ，表⽰继续分割同⼀个字符串。
//2. delim ：包含所有可能分隔符的字符串（每个字符均视为独⽴的分隔符）。
//返回值
//• 成功时返回指向当前⼦字符串的指针。
//• 没有更多⼦字符串时返回NULL 。
//使⽤步骤
//1. ⾸次调⽤：传⼊待分割字符串和分隔符。
//2. 后续调⽤：传⼊NULL 和相同的分隔符，继续分割。
//3. 结束条件：当返回NULL 时，表⽰分割完成。
//int main()
//{
//	char arr[] = "136.。。3。。627.....9595.";
//	const char* sep = ".";
//	char* str = NULL;
//	char buf[30] = { 0 };
//	strcpy(buf, arr);		//将arr中的字符串拷⻉到buf中，对buf的内容进⾏切割 
//	for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
//	{
//		printf("%s\n", str);
//	}
//	return 0;
//}
////11.2 注意事项
////• 破坏性操作： strtok 会直接修改原始字符串，将其中的分隔符替换为'\0' 。如果需要保留原
////字符串，应先拷⻉⼀份。
////• 连续分隔符：多个连续的分隔符会被视为单个分隔符，不会返回空字符串。
////• 空指针处理：如果输⼊的str 为NULL 且没有前序调⽤，⾏为未定义。
//12. strerror函数的使⽤
//1 char* strerror(int errnum);
//功能：
//1. strerror 函数可以通过参数部分的errnum 表⽰错误码，得到对应的错误信息，并且返回这
//个错误信息字符串⾸字符的地址。
//2. strerror 函数只针对标准库中的函数发⽣错误后设置的错误码的转换。
//3. strerror 的使⽤需要包含<string.h>
//在不同的系统和C语⾔标准库的实现中都规定了⼀些错误码，⼀般是放在 errno.h 这个头⽂件中说
//明的，C语⾔程序启动的时候就会使⽤⼀个全局的变量 errno 来记录程序的当前错误码，只不过程
//序启动的时候errno 是0，表⽰没有错误，当我们在使⽤标准库中的函数的时候发⽣了某种错误，
//就会将对应的错误码，存放在 errno 中，⽽⼀个错误码的数字是整数，很难理解是什么意思，所
//以每⼀个错误码都是有对应的错误信息的。strerror函数就可以将错误码对应的错误信息字符串的地
//址返回。
//参数：
//errnum ：表⽰错误码
//这个错误码⼀般传递的是 errno 这个变量的值，在C语⾔有⼀个全局的变量叫： errno ，当库函数
//的调⽤发⽣错误的时候，就会讲本次错误的错误码存放在 errno 这个变量中，使⽤这个全局变量需要
//包含⼀个头⽂件 errno.h 。
//返回值：
//函数返回通过错误码得到的错误信息字符串的⾸字符的地址。
//#include <errno.h>
//#include <string.h>
//#include <stdio.h>
////我们打印⼀下0~10这些错误码对应的信息 
//int main()
//{
//	int i = 0;
//	for (i = 0; i <= 10; i++) {
//		printf("%d: %s\n", i, strerror(i));
//	}
//	return 0;
//}
//0: No error
//1 : Operation not permitted
//2 : No such file or directory
//3 : No such process
//4 : Interrupted function call
//5 : Input / output error
//6 : No such device or address
//7 : Arg list too long
//8 : Exec format error
//9 : Bad file descriptor
//10 : No child processes
//#include <stdio.h>
//#include <string.h>
//#include <errno.h>
//int main()
//{
//	FILE* pFile = NULL;
//	//fopen函数以读的形式打开⽂件，如果⽂件不存在，则打开失败。 
//	pFile = fopen("unexist.ent", "r");
//	if (pFile == NULL)
//	{
//		printf("错误信息是：%s\n", strerror(errno));
//		return 1;//错误返回 
//	}
//
//	return 0;
//}
//错误信息是：No such file or directory
//12.2 perror
//也可以了解⼀下 perror 函数， perror 函数相当于⼀次将上述代码中的第11⾏完成了，直接将错误
//信息打印出来。 perror 函数打印完参数部分的字符串后，再打印⼀个冒号和⼀个空格，再打印错误
//信息。
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
	FILE* pFile = NULL;
	pFile = fopen("unexist.ent", "r");
	if (pFile == NULL)
	{
		perror("错误信息是");
		return 1;
	}
	return 0;
}
错误信息是: No such file or directory
